Webframeworkk/ASP.NET Core/Routing

Dieses Tutorial behandelt das Routing speziell im Kontext von ASP.NET Core MVC. Es erklärt, wie eingehende Anfragen an Controller und deren Action-Methoden weitergeleitet werden.

1. Routing-Typen in MVC

In ASP.NET Core MVC gibt es zwei Hauptarten des Routings:

1. Attribute Routing (Attribut-basiertes Routing): Definition von Routen direkt an Controllern oder Action-Methoden mithilfe von Attributen.

Vorteile:

• Präzision: Routen können sehr spezifisch für einzelne Actions definiert werden.
• Lesbarkeit: Die Zuordnung von URL zu Code ist direkt am Controller/Action ersichtlich.
• Flexibilität: Einfache Handhabung von komplexen URL-Parametern und Constraints.

Nachteile:

• Fehlende Zentralisierung: Es gibt keinen einzigen Ort, an dem alle Routen der Anwendung eingesehen werden können.
• Redundanz: Ähnliche Routenmuster müssen oft an mehreren Stellen wiederholt werden.
• Wartungsaufwand: Bei globalen URL-Änderungen müssen viele Attribute in verschiedenen Dateien angepasst werden.

2. Program Routing

Hierbei definieren Sie ein oder mehrere globale Muster. Die Standardroute wird meist so konfiguriert:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

var app = builder.Build();

app.UseStaticFiles();

app.MapControllers()
    .WithStaticAssets();

app.Run();

Erklärung der Methoden:

• app.MapControllers(): Konfiguriert das Framework so, dass es Controller-Endpunkte erkennt und Routen basierend auf Attributen oder Konventionen zuordnet.
• .WithStaticAssets(): Eine Optimierung für statische Dateien (CSS, JS), die Fingerprinting für effektives Caching nutzt (eingeführt in .NET 9).

3. Attribute Routing

Attribute Routing ist flexibler und wird für REST-APIs oder komplexe URL-Strukturen bevorzugt. Bei Verwendung von MVC muss hierfür app.MapControllers() aufgerufen werden.

[Route("shop")]
public class ProductController : Controller
{
    [Route("")] // URL: /shop
    [Route("index")] // URL: /shop/index
    public IActionResult List() 
    {
        return View();
    }

    [HttpGet("details/{id:int}")] // URL: /shop/details/5
    public IActionResult Details(int id)
    {
        return View(id);
    }
}

Wichtige Attribute

• [Route("path")]: Definiert den Basispfad oder spezifischen Pfad.
• [HttpGet], [HttpPost], etc.: Schränkt die Route auf eine HTTP-Methode ein.
• [Area("Admin")]: Ordnet den Controller einer Area zu.

4. Routen-Parameter und Model Binding

In MVC werden Routen-Parameter automatisch an die Argumente der Action-Methode gebunden (Model Binding).

// Route: /archive/{year}/{month}
[HttpGet("archive/{year:int}/{month:range(1,12)}")]
public IActionResult GetArchive(int year, int month)
{
    return Content($"Archiv für {month}/{year}");
}

5. Routen-Constraints in MVC

Constraints stellen sicher, dass eine Route nur matcht, wenn die Parameter bestimmte Kriterien erfüllen.

| Constraint | Beispiel | Beschreibung | |----------------|-------------------------|----------------------------| | :int | {id:int} | Muss eine Ganzzahl sein. | | :alpha | {name:alpha} | Nur Buchstaben. | | :regex() | {code:regex(^\\d``$)} | Matcht regulären Ausdruck. | | :minlength() | {slug:minlength(5)} | Mindestlänge des Strings. |

6. Token Replacement (Platzhalter)

In Attributen können Platzhalter verwendet werden, um Redundanz zu vermeiden.

Token-Variablen

• [controller]: Wird durch den Controller-Namen ersetzt.
• [action]: Wird durch den Action-Namen ersetzt.
• [area]: Wird durch den Area-Namen ersetzt.

[Route("[controller]/[action]")]
public class UserController : Controller
{
    [HttpGet] // URL: /user/profile
    public IActionResult Profile()
    {
        return View();
    }
}

7. Catch-All Parameter

Der Catch-All Parameter * erfasst alle verbleibenden URL-Segmente als einzelne Zeichenkette.

[HttpGet("Neuformular/{*slug}")] // URL: /Neuformular/artikel/2024/dezember
public IActionResult Index(string slug)
{
    // slug enthält: "artikel/2024/dezember"
    return Content($"Slug: {slug}");
}

Der Parameter {*slug} erfasst alle verbleibenden Pfad-Segmente nach "Neuformular/" als einzelne Zeichenkette und übergibt sie an die Action-Methode.

8. Arten von Attribute Routing

Im Attribute Routing gibt es verschiedene Möglichkeiten, Routen zu definieren:

• Einfache Routen: Direktes Zuweisen eines Pfads an eine Action oder einen Controller.

    [Route("produkte/liste")]
    public IActionResult List() { ... }
    

• Mehrere Routen für eine Action: Mehrere [Route]-Attribute an einer Methode.

    [Route("produkte")]
    [Route("produkte/index")]
    public IActionResult Index() { ... }
    

• HTTP-Methode-spezifische Attribute: Kombination von [HttpGet], [HttpPost] usw. mit Routen.

    [HttpPost("produkte/erstellen")]
    public IActionResult Create() { ... }
    

• Token-basierte Routen: Verwendung von Platzhaltern wie [controller] und [action].

    [Route("[controller]/[action]")]
    public IActionResult Edit() { ... }
    

• Routen mit Constraints: Einschränkung von Parametern direkt im Attribut.

    [HttpGet("produkte/{id:int}")]
    public IActionResult Details(int id) { ... }
    

Diese Flexibilität macht Attribute Routing besonders für komplexe oder REST-orientierte APIs attraktiv.